// ClaimJumpers

(define "SameTurn" (is Prev Mover))

(define "IsAJumpableSite"
    (is 
        In 
        (between)
        (difference 
            (sites Occupied by:Next)
            (sites (values Remembered))
)))

(define "CanHop"
    (can Move
        (forEach Piece
            (move Hop
                #1
                <Board:adj> 
                (between if:("IsAJumpableSite"))
                (to if:(is Empty (to))) 
))))

(define "OpponentHop"
    (forEach Piece
        (move Hop
            #1
            <Board:adj> 
            (between if:("IsAJumpableSite") (apply (set Pending (between))))
            (to if:(is Empty (to)))
            (then
                (and
                    {
                    (remember Value (value Pending))
                    (remove (value Pending))
                    (add (piece (id "Disc" Mover)) (to (value Pending)))
                    }
                    (then
                        (and
                            {
                            (set Pending)
                            (if ("CanHop" (from (last To))) (moveAgain))
                            }
)))))))

(define "ForcedHop"
    (if (= 0 (size Array (values Remembered)))
        ("OpponentHop" (from if:(!= (from) (last To))))
        ("OpponentHop" (from if:(= (from) (last To)))) // ("OpponentHop" (from if:(= (from) (last To))))
))

(define "Placement"
    (do
        (forget Value All)
        next:(move Add 
            (piece (id "Disc" Mover))
            (to (sites Empty))
            (then 
                (if (can Move  ("OpponentHop" (from if:(!= (from) (last To))))) (moveAgain))
))))

//---------------------------------------
// Main routine
//---------------------------------------

(game "Claim Jumpers"
    (players 2)
    (equipment
        {
        (board <Board:size> use:Vertex)
        (piece "Disc" Each)
        }
    )
    (rules 
        (start (set Score Each 0)) 
        (play
            (if
                ("SameTurn")
                ("ForcedHop")
                ("Placement")
                (then
                    (and
                        (set Score Mover (count Pieces Mover))
                        (set Score Next (count Pieces Next))
        )))) 
        (end 
            {
            (if
                (and
                    "EndCondition"
                    (= (score Mover) (score Next))
                )
                (result Mover Win)
            )
            
            (if
                (and
                    "EndCondition"
                    (!= (score Mover) (score Next))
                )
                (byScore)
            )
            }  
)))

(define "EndCondition" (or {(no Moves Next) (all Passed)} ) ) 

//---------------------------------------

(define "Tri46Bug"  (tri {4 6 4 7 4}))
(define "Tri56Bug"  (tri {5 6 5 7 5}))
(define "Tri57Bug"  (tri {5 7 5 8 5}))
(define "Tri78Bug"  (tri {7 8 7 10 6}))
(option "Board Size" <Board> args:{ <size> <adj> <diag> }
    {
    (item "Square 3 omni (13)" 
        <(add
            (remove (square 5) vertices:{
                0  1     3  4
                5           9 
                
                15          19
            20 21    23 24})
            edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 11} {9 12} {11 12}}
        )> 
    <All> <Thin> "Board & size: Orthogonal 3")
    (item "Square 4 omni (25)" 
        <(add
            (remove (square 7) vertices:{ 0 1 2 4 5 6 7 8 12 13 14 20 28 34 35 36 40 41 42 43 44 46 47 48})
            edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 20} {16 21} {20 23} {21 24} {23 24}}
        )> 
    <All> <Thin> "Board & size: Orthogonal 4")     
    (item "Hex 2-3 (12)"         <(tri {2 3 2 3 2})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 2 and 4")
    (item "Equiversi 2-4 (18)"   <(tri {2 4 2 4 2})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 2 and 4")
    (item "Hex 3-4 (27)"         <(tri {3 4 3 4 3})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 3 and 4")
    (item "Equiversi 3-5 (36)"   <(tri {3 5 3 5 3})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 3 and 5")***
    (item "Hex 4-5 (48)"         <(tri {4 5 4 5 4})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 4 and 5")**
    (item "Equiversi 4-6 (60)"   <"Tri46Bug">    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 4 and 6")
    (item "Equiversi 5-7 (90)"   <"Tri57Bug">    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 5 and 7")**
    (item "Hex 6-7 (108)"        <(tri {6 7 6 7 6})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 6 and 7")
    (item "Equiversi 6-8 (126)"  <(tri {6 8 6 8 6})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 6 and 8") 
    (item "Square 4 ortho (16)"  <(square 4)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 5") 
    (item "Square 6 ortho (36)"  <(square 6)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 7") 
    (item "Square 8 ortho (64)"  <(square 8)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 9") 
    (item "Square 10 ortho (100)" <(square 10)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 10") 
    (item "Hex 3 (19)"           <(tri Hexagon 3)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 3")
    (item "Hex 4 (37)"           <(tri Hexagon 4)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 4")
    (item "Hex 5 (61)"           <(tri Hexagon 5)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 5") 
    (item "Hex 5-6 (75)"         <"Tri56Bug">   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 5 and 6") // standard strategy
    (item "Hex 6 (91)"           <(tri Hexagon 6)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 6") 
    (item "Hex 7 (127)"          <(tri Hexagon 7)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 7")
    (item "Hex 7-8 (147)"        <"Tri78Bug">  <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 7 and 8")
    (item "Square 5 ortho (25)" <(square 5)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 5") 
    (item "Square 7 ortho (49)" <(square 7)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 7") 
    (item "Square 9 ortho (81)" <(square 9)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 9") 
    (item "Square 5 omni (41)" 
        <(add
            (remove (square 9) vertices:{
                0  1  2  3     5  6  7  8
                9 10 11          15 16 17
                18 19                25 26
                27                      35
                
                45                      53
                54 55                61 62 
                63 64 65          69 70 71
            72 73 74 75    77 78 79 80 })
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 31} {25 32} {31 36} {32 37} {36 39} {37 40} {39 40}} )> 
        
    <All> <Thin> "Board & size: Orthogonal 5")
    
    (item "Square 6 omni (61)" 
        <(add 
            (remove (square 11) vertices:{
                0   1   2   3   4       6   7   8   9  10 
                11  12  13  14              18  19  20  21 
                22  23  24                      30  31  32  
                33  34                              42  43  
                44                                      54  
                
                66                                      76  
                77  78                              86  87  
                88  89  90                      96  97  98  
                99 100 101 102             106 107 108 109 
            110 111 112 113 114     116 117 118 119 120 }) 
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 35} {25 36} {35 44} {36 45} {44 51} {45 52} {51 56} {52 57} {56 59} {57 60} {59 60}} )>
        
    <All> <Thin> "Board & size: Orthogonal 6") 
    
    (item "Square 7 omni (85)" 
        <(add
            (remove (square 13) vertices:{
                0   1   2   3   4   5       7   8   9  10  11  12  
                13  14  15  16  17              21  22  23  24  25  
                26  27  28  29                      35  36  37  38  
                39  40  41                              49  50  51  
                52  53                                      63  64  
                65                                              77  
                
                91                                             103 
                104 105                                     115 116 
                117 118 119                             127 128 129 
                130 131 132 133                     139 140 141 142 
                143 144 145 146 147             151 152 153 154 155 
            156 157 158 159 160 161     163 164 165 166 167 168 })
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 35} {25 36} {35 48} {36 49} {48 59} {49 60} {59 68} {60 69} {68 75} {69 76} {75 80} {76 81} {80 83} {81 84} {83 84}} )>
        
    <All> <Thin> "Board & size: Orthogonal 7") 
    }
)

//----------------------------------------------------------

(metadata
    (info
        {
        (description "Claim Jumpers was part of a series of games created while travelling, that sought to simplify some of my earlier games to there barest essentials.
            A new element is placement before movement, but movement excludes the placed piece. 
            This is similar to placement after the movement with restriction against placement to the movement origin site; but it also allows for placement that precludes the forced movement in certain cases.
            The essence of the game is to force the opponent to capture your pieces in ways that allow greater capture-backs, and then hold onto that lead or increase it.
            The game seems to be very interesting tactically, open to global strategies, but not forcing global play, due to the complexity and balance of local play.  Other than board edges, defensive resources include thick, rounded blocks of pieces - which does involve mid-range placements.
        The A/B AI is strong on small tactical boards.")
        (rules "Claim Jumpers is a 2-player strategy game
            It may be played: 
            -- on a hex grid
            -- on a square grid
            -- on a square plus diagonal grid
            
            The goal is to maximize your pieces when the board is full. 
            A new piece is placed at the beginning of each turn. Followed, if possible, by a chain of forced jumps made by a different piece, that capture by 'flipping' the jumped opponent to your own color.
            
            The board starts empty. Turns alternate starting with White.
            Game ends when the board is full. No passing.
            
        Maximum captures are not required, but the piece choen to capture must capture at least one, and maynot stop capturing as long as it is able to capture the next adjacent opponent's piece.")
        (id "3961")
        (version "1.3.12")
        (classification "board/war/leaping/lines")
        (author "Dale W. Walton")
        (credit "Dale W. Walton")
        (date "31-12-2022")
        }
    )
    
    (graphics 
        {
        (board Style Graph)
        (board Colour InnerEdges (colour 62 72 55))
        (board Colour OuterEdges (colour 62 72 55))
        (board StyleThickness OuterEdges .25)
        (board StyleThickness InnerEdges .25)
        (show Edges Diagonal <Board:diag> (colour 62 72 55))
        (piece Scale P1 "Disc" 0.65)
        (piece Scale P2 "Disc" 0.65)
        (piece Scale P3 "Disc" 0.65)
        (piece Scale P4 "Disc" 0.65)
        (piece Scale P5 "Disc" 0.65)
        }
    )
    
)